//package com.example.trackcircuitdiagnosis.time;
//
//import com.example.trackcircuitdiagnosis.dto.KGLresDTO;
//import com.example.trackcircuitdiagnosis.entity.DeviceInformationEntity;
//import com.example.trackcircuitdiagnosis.service.DeviceInformationService;
//import com.example.trackcircuitdiagnosis.utils.RedisUtils;
//import com.fasterxml.jackson.core.JsonProcessingException;
//import com.fasterxml.jackson.core.type.TypeReference;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.databind.SerializationFeature;
//import com.fasterxml.jackson.databind.node.ArrayNode;
//import com.fasterxml.jackson.databind.node.JsonNodeFactory;
//import com.fasterxml.jackson.databind.node.ObjectNode;
// import javax.annotation.Resource;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.CommandLineRunner;
//import org.springframework.core.annotation.Order;
//import org.springframework.stereotype.Component;
//
//import java.io.*;
//import java.util.*;
//import java.util.stream.Collectors;
//
///**
// * 保存开关量和模拟量数据的组件 弃用
// */
//@Component
//@Order(value = 1)
//public class SaveBothData implements CommandLineRunner {
//
//    // Redis 工具类
//    @Resource
//    private RedisUtils redisUtils;
//
//    // 从 Excel 读取数据的组件
//    @Resource
//    private GetKglDataFromExcel readExcel;
//
//    // 用于存储模拟量数据的二维数组
//    public double[][] arr;
//
//    // ObjectMapper 用于 JSON 处理
//    public ObjectMapper objectMapper = new ObjectMapper();
//    @Autowired
//    private DeviceInformationService deviceInformationService;
//
//    private List<DeviceInformationEntity> deviceInformationEntities;
//
//    // 创建位置名称与索引的映射
//    private Map<String, Integer> positionIndexMap = new HashMap<>();
//
//    /**
//     * 初始化位置名称与索引的映射表
//     * 用于将位置名称映射到模拟量数组的索引位置
//     */
//    private SaveBothData(){
//        positionIndexMap.put("功出电压", 0);
//        positionIndexMap.put("功出载频", 1);
//        positionIndexMap.put("功出低频", 2);
//        positionIndexMap.put("功出电流", 3);
//        positionIndexMap.put("主轨入电压", 4);
//        positionIndexMap.put("主轨入载频", 5);
//        positionIndexMap.put("主轨入低频", 6);
//        positionIndexMap.put("小轨入电压", 7);
//        positionIndexMap.put("小轨入载频", 8);
//        positionIndexMap.put("小轨入低频", 9);
//        positionIndexMap.put("主轨出电压", 10);
//        positionIndexMap.put("小轨出电压", 11);
//        positionIndexMap.put("送端分线盘电压", 12);
//        positionIndexMap.put("发送电缆载频", 13);
//        positionIndexMap.put("发送电缆低频", 14);
//        positionIndexMap.put("受端分线盘电压", 15);
//        positionIndexMap.put("接收电缆载频", 16);
//        positionIndexMap.put("接收电缆低频", 17);
//    }
//
//    /**
//     * 运行时的初始化方法，保存所有数据
//     * @throws Exception 可能抛出的异常
//     */
//    @Override
//    public void run(String... args) throws Exception {
//        // saveAnalogData();
////         saveKGLData();
////        saveAllData();
//    }
//
//    /**
//     * 保存所有数据，包括模拟量和开关量数据
//     * @throws IOException IO 异常
//     */
//    private void saveAllData() throws IOException {
//        deviceInformationEntities = deviceInformationService.list();
//        for (int i = 1; i <= 86400; i++) {
//            soushuData(i);
//            System.out.println(i);
//        }
//    }
//
//    /**
//     * 保存开关量数据到 Redis
//     * @throws IOException IO 异常
//     */
//    public void saveKGLData() throws IOException {
////        if (redisUtils.hasKey("kgl")) {
////            // 如果已经存在开关量数据
////            System.out.println("已有开关量数据了");
////            return;
////        }
//
//        // 从 Excel 读取开关量数据
//        List<List<KGLresDTO>> list = readExcel.readKGL();
//
//        // 将开关量数据存入 Redis
////        boolean kgl = redisUtils.lSetList("kgl", list);
//        boolean kgl = writeToKglFile(list);
//
//        // 判断是否成功存储开关量数据
//        if (kgl) {
//            System.out.println("存完开关量数据了");
//            return;
//        }
//
//        // 存储数据出错
//        System.out.println("存储数据出错");
//    }
//
//    /**
//     * 将模拟量数据保存到 Redis
//     */
//    public void saveAnalogData() {
//        // 模拟量文件名前缀
//        String fileNamePrefix = "sData/array_file_";
//        if (redisUtils.hasKey("86400")) {
//            // 如果已经存在模拟量数据
//            System.out.println("已有模拟量数据了");
//            return;
//        }
//        // 清除之前存储的模拟量数据
//        if (redisUtils.hasKey("1")) {
//            for (int i = 0; i <= 86400; i++) {
//                redisUtils.del(String.valueOf(i));
//            }
//        }
//
//        // 设备数量
//        int deviceNum = 908;
//        // 每个文件包含的行数
//        int oneFileSecond = 3200;
//
//        // 从 Redis 中保存模拟量数据
//        loadArrayFromRedis(fileNamePrefix, deviceNum * oneFileSecond);
//
//        // 打印模拟量数据存储完成信息
//        System.out.println("存完模拟量数据了");
//    }
//
//    /**
//     * 将开关量数据写入文件
//     * @param kgLretryDTOS 开关量数据列表
//     * @return 是否成功写入文件
//     * @throws IOException IO 异常
//     */
//    private boolean writeToKglFile(List<List<KGLresDTO>> kgLretryDTOS) throws IOException {
//        for (int i = 0; i < 86400; i++) {
//            File file = new File("D:\\sb\\开关量data\\" + String.valueOf(i + 1) + ".txt");
//            if (!file.exists()) {
//                file.createNewFile();
//            }
//            ObjectMapper objectMapper = new ObjectMapper();
//            objectMapper.enable(SerializationFeature.INDENT_OUTPUT); // 格式化输出
//            String json = objectMapper.writeValueAsString(kgLretryDTOS.get(i));
//
//            try (FileWriter fileWritter = new FileWriter(file.getName(), true);
//                 BufferedWriter bufferWritter = new BufferedWriter(fileWritter)) {
//                bufferWritter.write(json);
//            }
//            System.out.println(i);
//        }
//
//        return true;
//    }
//
//
//    /**
//     * 从 Redis 中保存模拟量数据
//     * @param fileNamePrefix 模拟量文件名前缀
//     * @param rowsPerFile 每个文件包含的行数
//     */
//    public void loadArrayFromRedis(String fileNamePrefix, int rowsPerFile) {
//        int fileIndex = 1;
//        int row = 0;
//        while (true) {
//            InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileNamePrefix + fileIndex);
//            try {
//                assert inputStream != null;
//                try (DataInputStream dis = new DataInputStream(inputStream)) {
//                    Float[] floatArr = new Float[908];
//                    for (int i = 0; i < rowsPerFile; i++) {
//                        try {
//                            floatArr[i % 908] = dis.readFloat();
//                            boolean all = (i + 1) % 908 == 0;
//                            if (all) {
//                                row++;
//                                redisUtils.lSet(String.valueOf(row), floatArr);
//                            }
//                        } catch (EOFException e) {
//                            break; // 到达文件末尾
//                        }
//                    }
//                }
//            } catch (IOException e) {
//                break; // 文件不存在或读取完毕
//            } catch (NullPointerException n) {
//                break;
//            }
//            fileIndex++;
//        }
//    }
//
//    /**
//     * 将模拟量数据写入文件
//     * @param floatArr 模拟量数据数组
//     * @param name 文件名
//     * @param path 文件路径
//     * @return 是否写入成功
//     * @throws IOException IO 异常
//     */
//    public boolean writeToMoniFile(Float[] floatArr, String name, String path) throws IOException {
//        File file = new File(path + name + ".txt");
//        if (!file.exists()) {
//            file.createNewFile();
//        }
//        try (FileWriter fileWritter = new FileWriter(file.getName(), true);
//             BufferedWriter bufferWritter = new BufferedWriter(fileWritter)) {
//            bufferWritter.write(Arrays.toString(floatArr));
//        }
//        System.out.println(name);
//        return true;
//    }
//
//    /**
//     * 将数据写入文本文件
//     *
//     * @param data 要写入文件的数据字符串
//     * @param name 文件名
//     * @param path 文件路径
//     * @return 写入是否成功，返回 true 表示成功，false 表示失败
//     * @throws IOException IO 异常
//     */
//    public boolean writeToDataFile(String data, String name, String path) throws IOException {
//        // 创建文件对象
//        File file = new File(path + name + ".txt");
//
//        // 如果文件不存在，则创建新文件
//        if (!file.exists()) {
//            file.createNewFile();
//        }
//
//        // 使用 try-with-resources 语句，确保资源关闭
//        try (FileWriter fileWriter = new FileWriter(file.getAbsolutePath(), true);
//             BufferedWriter bufferedWriter = new BufferedWriter(fileWriter)) {
//            // 将数据写入文件
//            bufferedWriter.write(data);
//        }
//
//        // 返回写入成功标志
//        return true;
//    }
//
//    /**
//     * 读取模拟量数据文本文件
//     *@param index 文件索引
//     * @return 模拟量数据字符串
//     */
//    private String readTxtAnalogData(int index) {
//        return readTxtFile("D:\\sb\\模拟量数据\\" + index + ".txt");
//    }
//
//    /**
//     * 读取开关量数据文本文件
//     * @param index 文件索引
//     * @return 开关量数据字符串
//     */
//    private String readTxtKglData(int index) {
//        return readTxtFile("D:\\sb\\开关量data\\" + index + ".txt");
//    }
//
//    /**
//     * 处理索引对应的数据并生成 JSON 格式的结果，然后将结果写入文件
//     *
//     * @param index 处理的索引
//     * @return 生成的 JSON 字符串，为空字符串
//     * @throws IOException IO 异常
//     */
//    private String soushuData(int index) throws IOException {
//        // 从文件读取模拟量数据和开关量数据
//        float[] analogData = convertStringToFloatArray(readTxtAnalogData(index));
//        List<KGLresDTO> kglData = convertStringToKglList(readTxtKglData(index));
//
//        JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
//
//        // 使用 Stream API 按照 did 字段分组
//        Map<Integer, List<DeviceInformationEntity>> groupedByDid = deviceInformationEntities.stream()
//                .collect(Collectors.groupingBy(DeviceInformationEntity::getDid));
//
//        ObjectNode jsonOneObject = objectMapper.createObjectNode();
//
//        // 遍历每个分组
//        groupedByDid.forEach((did, entities) -> {
//            ArrayNode jsonOneArray = nodeFactory.arrayNode();
//
//            // 初始化并放入 20 个值，每个值为 -1
//            for (int i = 0; i < 20; i++) {
//                jsonOneArray.add(-0.1);
//            }
//            // 填充模拟量数据
//            fillAnalogData(jsonOneArray, entities, analogData);
//
//            // 填充开关量数据
//            fillKglData(jsonOneArray, kglData, entities);
//
//            jsonOneObject.put(String.valueOf(did), jsonOneArray);
//        });
//
//        // 将结果写入文件
//        writeToDataFile(objectMapper.writeValueAsString(jsonOneObject), String.valueOf(index), "D:\\sb\\data\\");
//
//        return "";
//    }
//
//    /**
//     * 填充模拟量数据到 JSON 数组
//     *
//     * @param jsonOneArray JSON 数组
//     * @param entities 模拟量数据关联的设备信息列表
//     * @param analogData 模拟量数据数组
//     */
//    private void fillAnalogData(ArrayNode jsonOneArray, List<DeviceInformationEntity> entities, float[] analogData) {
//        for (DeviceInformationEntity entity : entities) {
//            String positionName = entity.getPositionName();
//            if (positionIndexMap.containsKey(positionName)) {
//                int jsonIndex = positionIndexMap.get(positionName);
//                jsonOneArray.set(jsonIndex, analogData[entity.getAdNumber()]);
//            } else {
//                System.out.println("Error: Unknown position name - " + positionName);
//            }
//        }
//    }
//
//    /**
//     * 填充开关量数据到 JSON 数组
//     *
//     * @param jsonOneArray JSON 数组
//     * @param kglData 开关量数据列表
//     * @param entities 开关量数据关联的设备信息列表
//     */
//    private void fillKglData(ArrayNode jsonOneArray, List<KGLresDTO> kglData, List<DeviceInformationEntity> entities) {
//        for (KGLresDTO kglItem : kglData) {
//            if (kglItem.getDid() == entities.get(0).getDid()) {
//                int jsonIndex = "-XGJ".equals(kglItem.getPositionName()) ? 18 : 19;
//                jsonOneArray.set(jsonIndex, kglItem.getValue());
//            }
//        }
//    }
//
//
//    /**
//     * 读取文本文件内容
//     *
//     * @param filePath 文件路径
//     * @return 文件内容字符串
//     */
//    private String readTxtFile(String filePath) {
//        StringBuilder content = new StringBuilder();
//        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
//            reader.lines().forEach(content::append);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return content.toString();
//    }
//
//    /**
//     * 将字符串解析为 float 数组
//     *
//     * @param dataString 要解析的字符串
//     * @return 解析后的 float 数组
//     */
//    private float[] convertStringToFloatArray(String dataString) {
//        try {
//            // 使用 ObjectMapper 将字符串解析成 float 数组
//            return objectMapper.readValue(dataString, float[].class);
//        } catch (IOException e) {
//            e.printStackTrace();
//            // 在出现异常时返回一个空的 float 数组，你可以根据实际需求处理异常
//            return new float[0];
//        }
//    }
//
//    /**
//     * 将字符串解析为 KGLresDTO 列表
//     *
//     * @param dataString 要解析的字符串
//     * @return 解析后的 KGLresDTO 列表
//     */
//    private List<KGLresDTO> convertStringToKglList(String dataString) {
//        try {
//            // 使用 ObjectMapper 将字符串解析成 KGLresDTO 列表
//            return objectMapper.readValue(dataString, new TypeReference<List<KGLresDTO>>() {});
//        } catch (JsonProcessingException e) {
//            e.printStackTrace();
//            // 处理异常时返回一个空的列表
//            return Collections.emptyList();
//        }
//    }
//
//
//
//}
